Deriving Design Aspects from Conceptual Models

Two fundamental issues in aspect orientation are the identification and the composition of aspects. We argue that aspects must be identified at the requirement and the domain analysis phases. We also propose a mechanism for gradually composing aspects throughout the software development process. We illustrate our ideas for the design of a transaction framework

Automating the Object-Oriented Software Development Process: Workshop Report

Cost-effective realization of robust, adaptable and reusable software systems demands efficient and effective management of the overall software production process. Current object-oriented methods are not completely formalized and lack the ability of reasoning about the quality of processes and software products (artifacts). There is a need for new modeling formalisms, which enable the quantification of the required quality attributes and support the automation of the object-oriented development process (AOOSD). The ECOOP'98 AOOSD workshop was organized to identify the important issues in this direction

Component Composability Issues in Object-Oriented Programming

Building software from reusable components is considered important in reducing development costs. Object-oriented languages such as C++, Smalltalk and Java, however, are not capable of expressing certain aspects of applications in a composable way. Software engineers may experience difficulties in composing applications from components, for example if components implement code for multiple views, dynamic inheritance and synchronization [Aksit96]. If these aspects have to be programmed, then object-oriented languages may require a considerable amount of redefinition although this may not be intuitively necessary. To solve the composability problems, languages must be enhanced modularly without losing their basic characteristics. In addition, since more than one problem can be experienced for the same object, enhancements must be independent from each other. We have extended the conventional object-oriented model using the concept of composition-filters. Composition-filters can be attached to objects expressed for example in Smalltalk and Java. A number of different filter types have been defined, each addressing a certain concern. This paper first illustrates some practical problems and then introduces composition-filters solutions to overcome these problems

Providing Automatic Support for Heuristic Rules of Methods

In method-based software development, software engineers create artifacts based on the heuristic rules of the adopted method. Most CASE tools, however, do not actively assist software engineers in applying the heuristic rules. To provide an active support, the rules must be formalized, implemented and integrated within the framework of current CASE tools. In this paper we describe an approach for formalizing the heuristic rules of methods

Evaluating Architecture Implementation Alternatives based on Adaptibility Concerns

Software is rarely designed for ultimate adaptability, performance or reusability but rather it is a compromise of multiple considerations. Even for a simple architecture specification, one may identify many alternative implementations. This paper makes an attempt to depict the space of implementation alternatives of architectures, and to define rules for selecting them. The applicability of this approach is illustrated by means of a simple design problem

Aspect-Oriented Programming using Composition-Filters

Software engineers may experience problems in modeling certain aspects while applying object-oriented techniques [4, 10, 11]. Composition-Filters are capable of expressing various different kinds of aspects in a uniform manner. These aspects are, for example, inheritance and delegation [1] and atomic delegation [2], multiple views, dynamic inheritance and queries on objects [3], coordinated behavior and inter-object constraints [5], real-time [6] and composing real-time and synchronization together [9], synchronization [8] and distributed synchronization [7], and client-server architectures [10]

The Six concerns for Separation of Concerns

Despite a common agreement on the necessity of the application of the separation of concerns (SOC) principle, there is not yet a consensus for its key issues. The separation of the concerns is usually based on the adopted programming paradigm, the applied method or even the programming language. This paper presents the so-called six ‘C’ properties that can be applied as a guideline for defining and evaluating the approaches that adopt the SOC principle

Modular and composable extensions to smalltalk using composition filters

Current and future trends in computer science require extensions to Smalltalk. Rather than arguing for particular language mechanisms to deal with specific requirements, in this position paper we want to make a case for two requirements that Smalltalk extensions should fulfill. The first is that the extensions must be integrated with Smalltalk without violating its basic object model. The second requirement is that extensions should allow for defining objects that are still adaptable, extensible and reusable, and in particular do not cause inheritance anomalies. We propose the composition filters model as a framework for language extensions that fulfills these criteria. Its applicability to solving various modeling problems is briefly illustrated

Classifying and evaluating architecture design methods

The concept of software architecture has gained a wide popularity and is generally considered to play a fundamental role in coping with the inherent difficulties of the development of large-scale and complex software systems. This document first gives a definition of architectures. Second, a meta-model for architecture design methods is presented. This model is used for classifying and evaluating various architecture design approaches. The document concludes with the description of the identified problems